home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 27 / CU Amiga Magazine's Super CD-ROM 27 (1998)(EMAP Images)(GB)[!][issue 1998-10].iso / CUCD / PowerPC / vbcc / Examples / nsieve / nsieve.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-02  |  22.0 KB  |  884 lines
  1. /****************** Start NSIEVE C Source Code ************************/
  2.  
  3. /****************************************************************/
  4. /*                          NSIEVE                              */
  5. /*                     C Program Source                         */
  6. /*          Sieve benchmark for variable sized arrays           */
  7. /*                Version 1.2b, 26 Sep 1992                     */
  8. /*              Al Aburto  (aburto@nosc.mil)                    */
  9. /*                                                              */
  10. /*                                                              */
  11. /* This Sieve of Eratosthenes program works with variable size  */
  12. /* arrays. It is a straight forward extension of the original   */
  13. /* Gilbreath version ( Gilbreath, Jim. "A High-Level Language   */
  14. /* Benchmark." BYTE, September 1981, p. 180, and also Gilbreath,*/ 
  15. /* Jim and Gary. "Eratosthenes Revisited: Once More Through the */
  16. /* Sieve." BYTE January 1983, p. 283 ). Unlike the Sieve of     */
  17. /* Gilbreath, NSIEVE uses register long variables, pointers,and */ 
  18. /* large byte arrays via 'malloc()'.  Maximum array size is     */
  19. /* currently set at 2.56 MBytes but this can be increased or    */
  20. /* decreased by changing the program LIMIT constant.  NSIEVE    */
  21. /* provides error checking to ensure correct operation.  Timer  */
  22. /* routines are provided for several different systems. NSIEVE  */
  23. /* results won't generally agree with the Gilbreath Sieve       */
  24. /* results because NSIEVE specifically uses register long       */
  25. /* variables. NSIEVE, and Sieve, are programs designed          */
  26. /* specifically to generate and printout prime numbers (positive*/ 
  27. /* integers which have no other integral factor other than      */
  28. /* itself and unity, as 2,3,5,7,11, ... ). NSIEVE does not      */
  29. /* conduct the 'typical' instructions one might expect from the */
  30. /* mythical 'typical program'. NSIEVE results can be used to    */
  31. /* gain a perspective into the relative performance of different*/
  32. /* computer systems, but they can not be used in isolation to   */
  33. /* categorize the general performance capabilities of any       */
  34. /* computer system (no single benchmark program currently can do*/
  35. /* this).                                                       */
  36. /*                                                              */
  37. /* The program uses a maximum array size of 2.56 MBytes. You can*/
  38. /* increase or lower this value by changing the 'LIMIT' define  */
  39. /* from 9 to a higher or lower value.  Some systems (IBM PC's   */
  40. /* and clones) will be unable to work beyond 'LIMIT = 3' which  */
  41. /* corresponds to an array size of only 40,000 bytes. Be careful*/
  42. /* when specifying LIMIT > 3 for these systems as the system may*/ 
  43. /* crash or hang-up. Normally NSIEVE will stop program execution*/  
  44. /* when 'malloc()' fails.                                       */
  45. /*                                                              */
  46. /* The maximum array size is given by:                          */
  47. /*              size = 5000 * ( 2 ** LIMIT ).                   */
  48. /*                                                              */
  49. /* The array 'Number_Of_Primes[LIMIT]' is intended to hold the  */
  50. /* correct number of primes found for each array size up to     */
  51. /* LIMIT = 20, but the array is only currently defined up to    */
  52. /* LIMIT = 13.                                                  */
  53. /*                                                              */
  54. /* Program outputs to check for correct operation:              */
  55. /*    Array Size  LIMIT    Primes Found      Last Prime         */
  56. /*     (Bytes)                                                  */
  57. /*         8191       0            1899           16381         */
  58. /*        10000       1            2261           19997         */
  59. /*        20000       2            4202           39989         */
  60. /*        40000       3            7836           79999         */
  61. /*        80000       4           14683          160001         */
  62. /*       160000       5           27607          319993         */
  63. /*       320000       6           52073          639997         */
  64. /*       640000       7           98609         1279997         */
  65. /*      1280000       8          187133         2559989         */
  66. /*      2560000       9          356243         5119997         */
  67. /*      5120000      10          679460        10239989         */
  68. /*     10240000      11         1299068        20479999         */
  69. /*     20480000      12         2488465        40960001         */
  70. /*     40960000      13         4774994        81919993         */
  71. /*     81920000      14         -------       ---------         */
  72. /****************************************************************/
  73.  
  74. /****************************************************/
  75. /* Example Compilation:                             */
  76. /* (1) UNIX Systems:                                */
  77. /*     cc -O -DUNIX nsieve.c -o nsieve              */
  78. /*     cc -DUNIX nsieve.c -o nsieve                 */
  79. /****************************************************/
  80.  
  81. /***************************************************************/
  82. /* Timer options. You MUST uncomment one of the options below  */
  83. /* or compile, for example, with the '-DUNIX' option.          */
  84. /***************************************************************/
  85. /* #define Amiga       */
  86. /* #define UNIX        */
  87. /* #define UNIX_Old    */
  88. /* #define VMS         */
  89. /* #define BORLAND_C   */
  90. /* #define MSC         */
  91. /* #define MAC         */
  92. /* #define IPSC        */
  93. /* #define FORTRAN_SEC */
  94. /* #define GTODay      */
  95. /* #define CTimer      */
  96. /* #define UXPM        */
  97. /* #define MAC_TMgr    */
  98. /* #define PARIX       */
  99. /* #define POSIX       */
  100. /* #define WIN32       */
  101. /* #define POSIX1      */
  102. /***********************/
  103.  
  104. #include <stdio.h>
  105. #ifndef vax
  106. #include <stdlib.h>
  107. #endif
  108. #include <math.h>
  109.             /***********************************************/
  110. #define LIMIT 9      /* You may need to change this to '3' for PC's */
  111.             /* and Clones or you can experiment with higher*/
  112.             /* values, but '13' is currently the max.      */
  113.             /***********************************************/
  114.  
  115. #ifdef Amiga
  116. #include <exec/types.h>
  117. #include <ctype.h>
  118. #include "nsieve_protos.h"
  119. #endif
  120.  
  121. #ifdef BORLAND_C
  122. #include <ctype.h>
  123. #include <dos.h>
  124. #endif
  125.  
  126. #ifdef MSC
  127. #include <ctype.h>
  128. #endif
  129.  
  130. #ifndef TRUE
  131. #define TRUE 1
  132. #define FALSE 0
  133. #endif
  134.  
  135. double nulltime,runtime,TimeArray[4];
  136. double reftime,adj_time,emips;
  137. double hmips,lmips,smips[21];
  138.  
  139. long L_Prime,N_Prime;      /* Last Prime and Number of Primes Found */
  140. long ErrorFlag;
  141.  
  142. long Number_Of_Primes[21]; /* List of Correct Number of Primes for */
  143.               /* each sieve array size.               */
  144.  
  145. long NLoops[21];
  146.  
  147.  
  148. main()
  149. {
  150.  
  151. long  i,j,k,p;
  152. double sumtime;
  153.  
  154.  
  155. printf("\n   Sieve of Eratosthenes (Scaled to 10 Iterations)\n");
  156. printf("   Version 1.2b, 26 Sep 1992\n\n");
  157. printf("   Array Size   Number   Last Prime     Linear");       
  158. printf("    RunTime    MIPS\n");
  159. printf("    (Bytes)   of Primes               Time(sec)");      
  160. printf("    (Sec)\n");
  161.  
  162.        
  163.            /*******************************/
  164.            /* Number of        Array Size */
  165.            /* Primes Found      (Bytes)   */
  166. Number_Of_Primes[0] =     1899;      /*       8191 */
  167. Number_Of_Primes[1] =     2261;      /*      10000 */
  168. Number_Of_Primes[2] =     4202;      /*      20000 */
  169. Number_Of_Primes[3] =     7836;      /*      40000 */
  170. Number_Of_Primes[4] =    14683;      /*      80000 */
  171. Number_Of_Primes[5] =    27607;      /*     160000 */
  172. Number_Of_Primes[6] =    52073;      /*     320000 */
  173. Number_Of_Primes[7] =    98609;      /*     640000 */
  174. Number_Of_Primes[8] =   187133;      /*    1280000 */
  175. Number_Of_Primes[9] =   356243;      /*    2560000 */
  176. Number_Of_Primes[10]=   679460;      /*    5120000 */
  177. Number_Of_Primes[11]=  1299068;      /*   10240000 */
  178. Number_Of_Primes[12]=  2488465;      /*   20480000 */
  179. Number_Of_Primes[13]=  4774994;      /*   40960000 */
  180. Number_Of_Primes[14]=        0;      /*   81920000 */
  181. Number_Of_Primes[15]=        0;      /*  163840000 */
  182.  
  183. j = 8191;
  184. k = 256;
  185. p = 0;
  186. SIEVE(j,k,p);
  187.  
  188. for( i=1 ; i<= 20 ; i++)
  189. {
  190.  NLoops[i] = 1;
  191. }
  192.  
  193. p = 8;
  194. if ( runtime > 0.125 ) p = 1;
  195.  
  196. NLoops[0] = 256 * p; 
  197. NLoops[1] = 256 * p; 
  198. NLoops[2] = 128 * p;
  199. NLoops[3] =  64 * p;
  200. NLoops[4] =  32 * p;
  201. NLoops[5] =  16 * p;
  202. NLoops[6] =   8 * p;
  203. NLoops[7] =   4 * p;
  204. NLoops[8] =   2 * p;
  205. NLoops[9] =       p;
  206. NLoops[10] =  p / 2;
  207. NLoops[11] =  p / 4;
  208.  
  209. if ( p == 1 )
  210. {
  211. NLoops[10] = 1;
  212. NLoops[11] = 1;
  213. }
  214.  
  215. sumtime = 0.0;
  216. i = 0;
  217. j = 8191;
  218. k = NLoops[0];
  219. SIEVE(j,k,p);
  220. sumtime = sumtime + runtime;
  221. smips[i] = emips;
  222.  
  223. j = 5000;
  224. ErrorFlag = 0;
  225.  
  226. for( i=1 ; i<= LIMIT ; i++)
  227. {
  228.    j = 2 * j;
  229.  
  230.    k = NLoops[i];
  231.  
  232.    SIEVE(j,k,p);
  233.    smips[i] = emips;
  234.  
  235.    if( ErrorFlag == 0L )
  236.    {
  237.    if( N_Prime != Number_Of_Primes[i] )
  238.    {
  239.    printf("\n   Error --- Incorrect Number of Primes for Array: %ld\n",j);
  240.    printf("   Number of  Primes  Found is: %ld\n",N_Prime);
  241.    printf("   Correct Number of Primes is: %ld\n",Number_Of_Primes[i]);
  242.    ErrorFlag = 1L;
  243.    }
  244.    }
  245.  
  246.    if( ErrorFlag > 0L ) break;
  247.  
  248.    sumtime = sumtime + runtime * ( 8191.0 / (double)j );
  249.  
  250. }
  251.  
  252. if( ErrorFlag == 2L )
  253. {
  254. printf("\n   Could Not Allocate Memory for Array Size: %ld\n",j);
  255. }
  256.  
  257. sumtime = sumtime / (double)i;
  258.  
  259. hmips = 0.0;
  260. lmips = 1.0e+06;
  261. for( k=0 ; k < i ; k++)
  262. {
  263. if( smips[k] > hmips ) hmips = smips[k];
  264. if( smips[k] < lmips ) lmips = smips[k];
  265. }
  266.  
  267. printf("\n   Relative to 10 Iterations and the 8191 Array Size:\n");
  268. printf("   Average RunTime = %8.3f (sec)\n",sumtime);
  269. printf("   High  MIPS      = %8.1f\n",hmips);
  270. printf("   Low   MIPS      = %8.1f\n\n",lmips);
  271.  
  272. }
  273.  
  274.  
  275. /**************************************/
  276. /*  Sieve of Erathosthenes Program    */
  277. /**************************************/
  278.  
  279. SIEVE(long m,long n,long p)
  280. {
  281.  
  282. register char *flags;
  283. register long i,prime,k,ci;
  284. register long count,size;
  285.  
  286. long  iter,j;
  287.  
  288. char *ptr;
  289.  
  290. #ifdef vax
  291. char *malloc();
  292. int   free(); 
  293. #endif
  294.  
  295. size  = m - 1;
  296. ptr   = malloc(m);
  297.  
  298.    ErrorFlag = 0L;
  299.    N_Prime   = 0L;
  300.    L_Prime   = 0L;
  301.  
  302.    if( !ptr )
  303.      {
  304.      ErrorFlag = 2L;
  305.      return 0;
  306.      }
  307.  
  308.    flags = ptr;
  309.  
  310.    dtime(TimeArray);
  311.    dtime(TimeArray);
  312.    nulltime = TimeArray[1];
  313.    if ( nulltime < 0.0 ) nulltime = 0.0;
  314.  
  315.    j = 0;
  316.                           /****************/
  317.                           /* Instructions */
  318.                           /*    *iter     */
  319.                           /****************/
  320.    dtime(TimeArray);
  321.    for(iter=1 ; iter<=n ; iter++)                    
  322.    {
  323.    count = 0;                                       
  324.  
  325.    for(i=0 ; i<=size ; i++)                      
  326.    {
  327.    *(flags+i) = TRUE;                                /* 1*size  */
  328.    }                                                 /* 3*size  */
  329.                            
  330.    ci = 0;                                         
  331.      for(i=0 ; i<=size ; i++)                       
  332.      {
  333.     if(*(flags+i))                                /* 2*size  */
  334.     {                                             /* 1*count */
  335.     count++;                                      /* 1*count */
  336.     prime = i + i + 3;                            /* 3*count */
  337.     for(k = i + prime ; k<=size ; k+=prime)     /* 3*count */
  338.     {
  339.     ci++;                                       /* 1*ci    */
  340.     *(flags+k)=FALSE;                           /* 1*ci    */
  341.     }                                           /* 3*ci    */
  342.                             /* 1*count */
  343.     }
  344.      }                                               /* 3*size  */
  345.                            
  346.    j = j + count;                                   
  347.    }                                               
  348.                            
  349.    dtime(TimeArray);
  350.  
  351.    free(ptr);
  352.  
  353.    runtime = (TimeArray[1] - nulltime) * 10.0 / (double)n;
  354.  
  355.    if ( m == 8191 ) reftime = runtime;
  356.  
  357.    adj_time = reftime * ( (double)m / 8191.0 );
  358.  
  359.    emips = 9.0*(double)size+9.0*(double)count;
  360.    emips = emips+5.0*(double)ci;
  361.    emips = 1.0e-05*(emips/runtime);
  362.  
  363.    N_Prime = j / n;
  364.    L_Prime = prime;
  365.  
  366.    if ( p != 0L )
  367.    {
  368.    printf("  %9ld   %8ld     %8ld  ",m,N_Prime,L_Prime);
  369.    printf("%9.3f  %9.3f  %6.1f\n",adj_time,runtime,emips);
  370.    }
  371.  
  372. return 0;
  373. }
  374.  
  375. /*****************************************************/
  376. /* Various timer routines.                           */
  377. /* Al Aburto, aburto@nosc.mil, 18 Feb 1997           */
  378. /*                                                   */
  379. /* dtime(p) outputs the elapsed time seconds in p[1] */
  380. /* from a call of dtime(p) to the next call of       */
  381. /* dtime(p).  Use CAUTION as some of these routines  */
  382. /* will mess up when timing across the hour mark!!!  */
  383. /*                                                   */
  384. /* For timing I use the 'user' time whenever         */
  385. /* possible. Using 'user+sys' time is a separate     */
  386. /* issue.                                            */
  387. /*                                                   */
  388. /* Example Usage:                                    */
  389. /* [Timer options added here]                        */
  390. /* double RunTime, TimeArray[3];                     */
  391. /* main()                                            */
  392. /* {                                                 */
  393. /* dtime(TimeArray);                                 */ 
  394. /* [routine to time]                                 */
  395. /* dtime(TimeArray);                                 */
  396. /* RunTime = TimeArray[1];                           */
  397. /* }                                                 */
  398. /* [Timer code added here]                           */
  399. /*****************************************************/
  400.  
  401. /******************************/
  402. /* Timer code.                */
  403. /******************************/
  404.  
  405. /*******************/
  406. /*  Amiga dtime()  */
  407. /*******************/
  408. #ifdef Amiga
  409. #include <ctype.h>
  410. #include <proto/dos.h>
  411. #define HZ 50
  412.  
  413. dtime(double *p)
  414. {
  415.  double q;
  416.  
  417.  struct tt {
  418.     long  days;
  419.     long  minutes;
  420.     long  ticks;
  421.  } tt;
  422.  
  423.  q = p[2];
  424.  
  425.  DateStamp((struct DateStamp*)&tt);
  426.  
  427.  p[2] = ( (double)(tt.ticks + (tt.minutes * 60L * 50L)) ) / (double)HZ;
  428.  p[1] = p[2] - q;
  429.     
  430.  return 0;
  431. }
  432. #endif
  433.  
  434. /*****************************************************/
  435. /*  UNIX dtime(). This is the preferred UNIX timer.  */
  436. /*  Provided by: Markku Kolkka, mk59200@cc.tut.fi    */
  437. /*  HP-UX Addition by: Bo Thide', bt@irfu.se         */
  438. /*****************************************************/
  439. #ifdef UNIX
  440. #include <sys/time.h>
  441. #include <sys/resource.h>
  442.  
  443. #ifdef hpux
  444. #include <sys/syscall.h>
  445. #define getrusage(a,b) syscall(SYS_getrusage,a,b)
  446. #endif
  447.  
  448. struct rusage rusage;
  449.  
  450. dtime(p)
  451. double p[];
  452. {
  453.  double q;
  454.  
  455.  q = p[2];
  456.  
  457.  getrusage(RUSAGE_SELF,&rusage);
  458.  
  459.  p[2] = (double)(rusage.ru_utime.tv_sec);
  460.  p[2] = p[2] + (double)(rusage.ru_utime.tv_usec) * 1.0e-06;
  461.  p[1] = p[2] - q;
  462.     
  463.  return 0;
  464. }
  465. #endif
  466.  
  467. /***************************************************/
  468. /*  UNIX_Old dtime(). This is the old UNIX timer.  */
  469. /*  Use only if absolutely necessary as HZ may be  */
  470. /*  ill defined on your system.                    */
  471. /***************************************************/
  472. #ifdef UNIX_Old
  473. #include <sys/types.h>
  474. #include <sys/times.h>
  475. #include <sys/param.h>
  476.  
  477. #ifndef HZ
  478. #define HZ 60
  479. #endif
  480.  
  481. struct tms tms;
  482.  
  483. dtime(p)
  484. double p[];
  485. {
  486.  double q;
  487.  
  488.  q = p[2];
  489.  
  490.  times(&tms);
  491.  
  492.  p[2] = (double)(tms.tms_utime) / (double)HZ;
  493.  p[1] = p[2] - q;
  494.     
  495.  return 0;
  496. }
  497. #endif
  498.  
  499. /*********************************************************/
  500. /*  VMS dtime() for VMS systems.                         */
  501. /*  Provided by: RAMO@uvphys.phys.UVic.CA                */
  502. /*  Some people have run into problems with this timer.  */
  503. /*********************************************************/
  504. #ifdef VMS
  505. #include time
  506.  
  507. #ifndef HZ
  508. #define HZ 100
  509. #endif
  510.  
  511. struct tbuffer_t
  512.       {
  513.        int proc_user_time;
  514.        int proc_system_time;
  515.        int child_user_time;
  516.        int child_system_time;
  517.       };
  518.  
  519. struct tbuffer_t tms;
  520.  
  521. dtime(p)
  522. double p[];
  523. {
  524.  double q;
  525.  
  526.  q = p[2];
  527.  
  528.  times(&tms);
  529.  
  530.  p[2] = (double)(tms.proc_user_time) / (double)HZ;
  531.  p[1] = p[2] - q;
  532.     
  533.  return 0;
  534. }
  535. #endif
  536.  
  537. /******************************/
  538. /*  BORLAND C dtime() for DOS */
  539. /******************************/
  540. #ifdef BORLAND_C
  541. #include <ctype.h>
  542. #include <dos.h>
  543. #include <time.h>
  544.  
  545. #define HZ 100
  546. struct time tnow;
  547.  
  548. dtime(p)
  549. double p[];
  550. {
  551.  double q;
  552.  
  553.  q = p[2];
  554.  
  555.  gettime(&tnow);
  556.  
  557.  p[2] = 60.0 * (double)(tnow.ti_min);
  558.  p[2] = p[2] + (double)(tnow.ti_sec);
  559.  p[2] = p[2] + (double)(tnow.ti_hund)/(double)HZ;
  560.  p[1] = p[2] - q;
  561.     
  562.  return 0;
  563. }
  564. #endif
  565.  
  566. /**************************************/
  567. /*  Microsoft C (MSC) dtime() for DOS */
  568. /**************************************/
  569. #ifdef MSC
  570. #include <time.h>
  571. #include <ctype.h>
  572.  
  573. #define HZ CLOCKS_PER_SEC
  574. clock_t tnow;
  575.  
  576. dtime(p)
  577. double p[];
  578. {
  579.  double q;
  580.  
  581.  q = p[2];
  582.  
  583.  tnow = clock();
  584.  
  585.  p[2] = (double)tnow / (double)HZ;
  586.  p[1] = p[2] - q;
  587.     
  588.  return 0;
  589. }
  590. #endif
  591.  
  592. /*************************************/
  593. /*  Macintosh (MAC) Think C dtime()  */
  594. /*************************************/
  595. #ifdef MAC
  596. #include <time.h>
  597.  
  598. #define HZ 60
  599.  
  600. dtime(p)
  601. double p[];
  602. {
  603.  double q;
  604.  
  605.  q = p[2];
  606.  
  607.  p[2] = (double)clock() / (double)HZ;
  608.  p[1] = p[2] - q;
  609.     
  610.  return 0;
  611. }
  612. #endif
  613.  
  614. /************************************************************/
  615. /*  iPSC/860 (IPSC) dtime() for i860.                       */
  616. /*  Provided by: Dan Yergeau, yergeau@gloworm.Stanford.EDU  */
  617. /************************************************************/
  618. #ifdef IPSC
  619. extern double dclock();
  620.  
  621. dtime(p)
  622. double p[];
  623. {
  624.   double q;
  625.  
  626.   q = p[2];
  627.  
  628.   p[2] = dclock();
  629.   p[1] = p[2] - q;
  630.     
  631.   return 0;
  632. }
  633. #endif
  634.  
  635. /**************************************************/
  636. /*  FORTRAN dtime() for Cray type systems.        */
  637. /*  This is the preferred timer for Cray systems. */
  638. /**************************************************/
  639. #ifdef FORTRAN_SEC
  640.  
  641. fortran double second();
  642.  
  643. dtime(p)
  644. double p[];
  645. {
  646.  double q,v;
  647.  
  648.  q = p[2];
  649.  
  650.  second(&v);
  651.  p[2] = v;
  652.  p[1] = p[2] - q;
  653.     
  654.  return 0;
  655. }
  656. #endif
  657.  
  658. /***********************************************************/
  659. /*  UNICOS C dtime() for Cray UNICOS systems.  Don't use   */
  660. /*  unless absolutely necessary as returned time includes  */
  661. /*  'user+system' time.  Provided by: R. Mike Dority,      */
  662. /*  dority@craysea.cray.com                                */
  663. /***********************************************************/
  664. #ifdef CTimer
  665. #include <time.h>
  666.  
  667. dtime(p)
  668. double p[];
  669. {
  670.  double    q;
  671.  clock_t   clock(void);
  672.  
  673.  q = p[2];
  674.  
  675.  p[2] = (double)clock() / (double)CLOCKS_PER_SEC;
  676.  p[1] = p[2] - q;
  677.  
  678.  return 0;
  679. }
  680. #endif
  681.  
  682. /********************************************/
  683. /* Another UNIX timer using gettimeofday(). */
  684. /* However, getrusage() is preferred.       */
  685. /********************************************/
  686. #ifdef GTODay
  687. #include <sys/time.h>
  688.  
  689. struct timeval tnow;
  690.  
  691. dtime(p)
  692. double p[];
  693. {
  694.  double q;
  695.  
  696.  q = p[2];
  697.  
  698.  gettimeofday(&tnow,NULL);
  699.  p[2] = (double)tnow.tv_sec + (double)tnow.tv_usec * 1.0e-6;
  700.  p[1] = p[2] - q;
  701.  
  702.  return 0;
  703. }
  704. #endif
  705.  
  706. /*****************************************************/
  707. /*  Fujitsu UXP/M timer.                             */
  708. /*  Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */
  709. /*****************************************************/
  710. #ifdef UXPM
  711. #include <sys/types.h>
  712. #include <sys/timesu.h>
  713. struct tmsu rusage;
  714.  
  715. dtime(p)
  716. double p[];
  717. {
  718.  double q;
  719.  
  720.  q = p[2];
  721.  
  722.  timesu(&rusage);
  723.  
  724.  p[2] = (double)(rusage.tms_utime) * 1.0e-06;
  725.  p[1] = p[2] - q;
  726.     
  727.  return 0;
  728. }
  729. #endif
  730.  
  731. /**********************************************/
  732. /*    Macintosh (MAC_TMgr) Think C dtime()    */
  733. /*   requires Think C Language Extensions or  */
  734. /*    #include <MacHeaders> in the prefix     */
  735. /*  provided by Francis H Schiffer 3rd (fhs)  */
  736. /*         skipschiffer@genie.geis.com        */
  737. /**********************************************/
  738. #ifdef MAC_TMgr
  739. #include <Time.h>
  740. #include <stdlib.h>
  741.  
  742. static TMTask   mgrTimer;
  743. static Boolean  mgrInited = FALSE;
  744. static double   mgrClock;
  745.  
  746. #define RMV_TIMER RmvTime( (QElemPtr)&mgrTimer )
  747. #define MAX_TIME  1800000000L
  748. /* MAX_TIME limits time between calls to */
  749. /* dtime( ) to no more than 30 minutes   */
  750. /* this limitation could be removed by   */
  751. /* creating a completion routine to sum  */
  752. /* 30 minute segments (fhs 1994 feb 9)   */
  753.  
  754. static void     Remove_timer( )
  755. {
  756.  RMV_TIMER;
  757.  mgrInited = FALSE;
  758. }
  759.  
  760. int     dtime( p )
  761. double p[];
  762. {
  763.  if ( mgrInited ) {
  764.     RMV_TIMER;
  765.     mgrClock += (MAX_TIME + mgrTimer.tmCount)*1.0e-6;
  766.     } else {
  767.     if ( _atexit( &Remove_timer ) == 0 ) mgrInited = TRUE;
  768.     mgrClock = 0.0;
  769.    }
  770.     
  771.  p[1] = mgrClock - p[2];
  772.  p[2] = mgrClock;
  773.  if ( mgrInited ) {
  774.     mgrTimer.tmAddr = NULL;
  775.     mgrTimer.tmCount = 0;
  776.     mgrTimer.tmWakeUp = 0;
  777.     mgrTimer.tmReserved = 0;
  778.     InsTime( (QElemPtr)&mgrTimer );
  779.     PrimeTime( (QElemPtr)&mgrTimer, -MAX_TIME );
  780.    }
  781.  return( 0 );
  782. }
  783. #endif
  784.  
  785. /***********************************************************/
  786. /*  Parsytec GCel timer.                                   */
  787. /*  Provided by: Georg Wambach, gw@informatik.uni-koeln.de */
  788. /***********************************************************/
  789. #ifdef PARIX
  790. #include <sys/time.h>
  791.  
  792. dtime(p)
  793. double p[];
  794. {
  795.  double q;
  796.  
  797.  q = p[2];
  798.  p[2] = (double) (TimeNowHigh()) / (double) CLK_TCK_HIGH;
  799.  p[1] = p[2] - q;
  800.  
  801.  return 0;
  802. }
  803. #endif
  804.  
  805. /************************************************/
  806. /*  Sun Solaris POSIX dtime() routine           */
  807. /*  Provided by: Case Larsen, CTLarsen@lbl.gov  */
  808. /************************************************/
  809. #ifdef POSIX
  810. #include <sys/time.h>
  811. #include <sys/resource.h>
  812. #include <sys/rusage.h>
  813.  
  814. #ifdef __hpux
  815. #include <sys/syscall.h>
  816. #define getrusage(a,b) syscall(SYS_getrusage,a,b)
  817. #endif
  818.  
  819. struct rusage rusage;
  820.  
  821. dtime(p)
  822. double p[];
  823. {
  824.  double q;
  825.  
  826.  q = p[2];
  827.  
  828.  getrusage(RUSAGE_SELF,&rusage);
  829.  
  830.  p[2] = (double)(rusage.ru_utime.tv_sec);
  831.  p[2] = p[2] + (double)(rusage.ru_utime.tv_nsec) * 1.0e-09;
  832.  p[1] = p[2] - q;
  833.     
  834.  return 0;
  835. }
  836. #endif
  837.  
  838. /****************************************************/
  839. /*  Windows NT (32 bit) dtime() routine             */
  840. /*  Provided by: Piers Haken, piersh@microsoft.com  */
  841. /****************************************************/
  842. #ifdef WIN32
  843. #include <windows.h>
  844.  
  845. dtime(p)
  846. double p[];
  847. {
  848.  double q;
  849.  
  850.  q = p[2];
  851.  
  852.  p[2] = (double)GetTickCount() * 1.0e-03;
  853.  p[1] = p[2] - q;
  854.  
  855.  return 0;
  856. }
  857. #endif
  858.  
  859. /*****************************************************/
  860. /* Time according to POSIX.1  -  <J.Pelan@qub.ac.uk> */
  861. /* Ref: "POSIX Programmer's Guide"  O'Reilly & Assoc.*/
  862. /*****************************************************/
  863. #ifdef POSIX1
  864. #define _POSIX_SOURCE 1
  865. #include <unistd.h>
  866. #include <limits.h>
  867. #include <sys/times.h>
  868.  
  869. struct tms tms;
  870.  
  871. dtime(p)
  872. double p[];
  873. {
  874.  double q;
  875.  times(&tms);
  876.  q = p[2];
  877.  p[2] = (double)tms.tms_utime / (double)CLK_TCK;
  878.  p[1] = p[2] - q;
  879.  return 0;
  880. }
  881. #endif
  882.  
  883. /*------ End of nsieve.c, say goodnight Liz! (Sep 1992) ------*/
  884.